//#include <iostream>
//#include <list>
//#include <vector>
//#include <algorithm>
//#include <array>
//#include <time.h>
//#include <queue>
//using namespace std;
//
//
//void test_list1()
//{
//	list<int> lt;
//	lt.push_back(1);
//	lt.push_back(2);
//	lt.push_back(3);
//	lt.push_back(4);
//	lt.push_back(5);
//
//	list<int>::iterator it = lt.begin();
//	while (it != lt.end())
//	{
//		cout << *it << " ";
//		++it;
//	}
//	cout << endl;
//
//	list<int>::reverse_iterator rit = lt.rbegin();
//	while (rit != lt.rend())
//	{
//		cout << *rit << " ";
//		++rit;
//	}
//	cout << endl;
//
//	it = lt.begin();
//	while (it != lt.end())
//	{
//		*it *= 2;
//		++it;
//	}
//	cout << endl;
//
//	for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	lt.push_front(10);
//	lt.push_front(20);
//	lt.push_front(30);
//	lt.push_front(40);
//
//	lt.pop_back();
//	lt.pop_back();
//
//	for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//
//void test_list2()
//{
//	list<int> lt;
//	lt.push_back(1);
//	lt.push_back(2);
//	lt.push_back(3);
//	lt.push_back(4);
//	lt.push_back(5);
//
//	auto pos = find(lt.begin(), lt.end(), 3);
//	if (pos != lt.end())
//	{
//		// pos不会失效
//		lt.insert(pos, 30);
//		//lt.insert(pos, 30);
//		*pos *= 100;
//	}
//
//	for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	pos = find(lt.begin(), lt.end(), 4);
//	if (pos != lt.end())
//	{
//		// pos会失效
//		lt.erase(pos);
//		// cout << *pos << endl;
//	}
//
//	for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//
//
//void test_list3()
//{
//	list<int> lt;
//	lt.push_back(1);
//	lt.push_back(3);
//	lt.push_back(2);
//	lt.push_back(3);
//	lt.push_back(4);
//	lt.push_back(3);
//	lt.push_back(3);
//	lt.push_back(5);
//
//	/*for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	lt.remove(3);
//
//	for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;*/
//
//	// sort(lt.begin(), lt.end());
//	lt.sort();
//
//	for (auto e : lt)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//
//// N个数据需要排序，vector+ 算法sort  list+ sort
//void test_op()
//{
//	srand(time(0));
//	const int N = 100000;
//	vector<int> v;
//	v.reserve(N);
//
//	list<int> lt1;
//	list<int> lt2;
//
//	for (int i = 0; i < N; ++i)
//	{
//		auto e = rand();
//		//v.push_back(e);
//		lt1.push_back(e);
//		lt2.push_back(e);
//	}
//
//	// 拷贝到vector排序，排完以后再拷贝回来
//	int begin1 = clock();
//	for (auto e : lt1)
//	{
//		v.push_back(e);
//	}
//	sort(v.begin(), v.end());
//	size_t i = 0;
//	for (auto& e : lt1)
//	{
//		e = v[i++];
//	}
//	int end1 = clock();
//
//	int begin2 = clock();
//	//sort(lt1.begin(), lt1.end());
//	lt2.sort();
//	int end2 = clock();
//
//	printf("copy vector sort:%d\n", end1 - begin1);
//	printf("list sort:%d\n", end2 - begin2);
//}

//int main()
//{
//	bit::test_list1();
//	bit::test_vector1();
//
//	//test_op();
//	//bit::test_list5();
//
//	return 0;
//}


// 非类型模板参数 -- 常量
//template<class T, size_t N = 10>
//class array
//{
//private:
//	T _a[N];
//};

//template<class T, double D = 1.1>
//template<class T, string S>
//class A
//{
//};

//int main()
//{
//	array<int> a0;
//	array<int, 100> a1;      // 100
//	array<double, 1000> a2;   // 1000
//
//	return 0;
//}

//int main()
//{
//	array<int, 10> a1;  // C++11
//	int a2[10];         // C
//
//	/*cout << sizeof(a1) << endl;
//	cout << sizeof(a2) << endl;*/
//
//	// 越界能查出来 -- 函数调用
//	//a1[10];
//	a1[15] = 0;
//
//	// 指针解引用 --  抽查是否越界，只针对越界写，越界读不检查
//	// a2[10];
//	// a2[10] = 1;
//	// a2[15] = 1;
//
//	return 0;


//struct Date
//{
//	Date(int year, int month, int day)
//		:_year(year)
//		, _month(month)
//		, _day(day)
//	{}
//
//	bool operator>(const Date& d) const
//	{
//		if ((_year > d._year)
//			|| (_year == d._year && _month > d._month)
//			|| (_year == d._year && _month == d._month && _day > d._day))
//		{
//			return true;
//		}
//		else
//		{
//			return false;
//		}
//	}
//
//	bool operator<(const Date& d) const
//	{
//		if ((_year < d._year)
//			|| (_year == d._year && _month < d._month)
//			|| (_year == d._year && _month == d._month && _day < d._day))
//		{
//			return true;
//		}
//		else
//		{
//			return false;
//		}
//	}
//
//	int _year;
//	int _month;
//	int _day;
//};
//
//// 函数模板 -- 参数匹配
//template<class T>
//bool Greater(T left, T right)
//{
//	return left > right;
//}
//
//// 特化--针对某些类型进行特殊化处理
//template<>
//bool Greater<Date*>(Date* left, Date* right)
//{
//	return *left > *right;
//}
//
///////////////////////////////////////////////////////////
//// 类模板
//namespace bit
//{
//	template<class T>
//	struct less
//	{
//		bool operator()(const T& x1, const T& x2) const
//		{
//			return x1 < x2;
//		}
//	};
//
//	// 特化
//	//template<>
//	//struct less<Date*>
//	//{
//	//	bool operator()(Date* x1, Date* x2) const
//	//	{
//	//		return *x1 < *x2;
//	//	}
//	//};
//}
//
//int main()
//{
//	cout << Greater(1, 2) << endl;   // 可以比较，结果正确
//
//	Date d1(2022, 7, 7);
//	Date d2(2022, 7, 8);
//	cout << Greater(d1, d2) << endl;  // 可以比较，结果正确
//
//	Date* p1 = &d1;
//	Date* p2 = &d2;
//	cout << Greater(p1, p2) << endl;  // 可以比较，结果错误
//
//	bit::less<Date> lessFunc1;
//	cout << lessFunc1(d1, d2) << endl;
//
//	bit::less<Date*> lessFunc2;
//	cout << lessFunc2(p1, p2) << endl;
//
//	std::priority_queue<Date, vector<Date>, bit::less<Date>> dq1;
//	std::priority_queue<Date*, vector<Date*>, bit::less<Date*>> dq2;
//	dq2.push(new Date(2022, 9, 27));
//	dq2.push(new Date(2022, 9, 25));
//	dq2.push(new Date(2022, 9, 28));
//	dq2.push(new Date(2022, 9, 29));
//
//
//	return 0;
//}

#include <iostream>
using namespace std;

template<class T1, class T2>
class Data
{
public:
	Data() { cout << "Data<T1, T2>" << endl; }
private:
	T1 _d1;
	T2 _d2;
};

// 全特化
template<>
class Data<int, char>
{
public:
	Data() { cout << "Data<int, char>" << endl; }
private:
	/*int _d1;
	char _d2;*/
};

// 偏特化
template <class T1>
class Data<T1, int>
{
public:
	Data() { cout << "Data<T1, int>" << endl; }
private:
	/*T1 _d1;
	int _d2;*/
};

template<class T1, class T2>
class Data<T1*, T2*>
{
public:
	Data() { cout << "Data<T1*, T2*>" << endl; }
};

template<class T1, class T2>
class Data<T1&, T2&>
{
public:
	Data() { cout << "Data<T1&, T2&>" << endl; }
};

template<class T1, class T2>
class Data<T1&, T2*>
{
public:
	Data() { cout << "Data<T1&, T2*>" << endl; }
};

int main()
{
	Data<int, int> d0;
	Data<double, int> d1;

	Data<int, char> d2;

	Data<double, double> d3;
	Data<double*, double*> d4;
	Data<int*, char*> d5;
	Data<int*, char> d6;

	Data<int&, char&> d7;
	Data<int&, double&> d8;
	Data<int&, double*> d9;

	return 0;
}

//int main()
//{
//	Less2<Date> LessFunc1;
//	Date d1(2023, 1, 1);
//	Date d2(2023, 1, 2);
//	cout << LessFunc1(d1, d2) << endl;  // 可以比较，结果正确
//
//	Less2<Date*> LessFunc2;
//	Date* p2 = &d2;
//	Date* p1 = &d1;
//	cout << LessFunc2(p1, p2) << endl;  // 可以比较，结果错误，加上类模板特化后结果正确
//
//	return 0;
//}
